<?php
/**
 * Zend Framework
 *
 * LICENSE
 *
 * This source file is subject to the new BSD license that is bundled
 * with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://framework.zend.com/license/new-bsd
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@zend.com so we can send you a copy immediately.
 *
 * @category   Zend
 * @package    Zend_Tool
 * @subpackage Framework
 * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 * @version    $Id: Repository.php 18951 2009-11-12 16:26:19Z alexander $
 */

/**
 * @see Zend_Tool_Framework_Registry_EnabledInterface
 */
require_once 'Zend/Tool/Framework/Registry/EnabledInterface.php';

/**
 * @category   Zend
 * @package    Zend_Tool
 * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 */
class Zend_Tool_Framework_Manifest_Repository
implements Zend_Tool_Framework_Registry_EnabledInterface, IteratorAggregate, Countable
{

	/**
	 * @var Zend_Tool_Framework_Provider_Registry_Interface
	 */
	protected $_registry = null;

	/**
	 * @var array
	 */
	protected $_manifests = array();

	/**
	 * @var array Array of Zend_Tool_Framework_Metadata_Interface
	 */
	protected $_metadatas = array();

	/**
	 * setRegistry()
	 *
	 * @param Zend_Tool_Framework_Registry_Interface $registry
	 * @return unknown
	 */
	public function setRegistry(Zend_Tool_Framework_Registry_Interface $registry)
	{
		$this->_registry = $registry;
		return $this;
	}

	/**
	 * addManifest() - Add a manifest for later processing
	 *
	 * @param Zend_Tool_Framework_Manifest_Interface $manifest
	 * @return Zend_Tool_Framework_Manifest_Repository
	 */
	public function addManifest(Zend_Tool_Framework_Manifest_Interface $manifest)
	{
		// we need to get an index number so that manifests with
		// higher indexes have priority over others
		$index = count($this->_manifests);

		if ($manifest instanceof Zend_Tool_Framework_Registry_EnabledInterface) {
			$manifest->setRegistry($this->_registry);
		}

		// if the manifest supplies a getIndex() method, use it
		if ($manifest instanceof Zend_Tool_Framework_Manifest_Indexable) {
			$index = $manifest->getIndex();
		}

		// get the required objects from the framework registry
		$actionRepository   = $this->_registry->getActionRepository();
		$providerRepository = $this->_registry->getProviderRepository();

		// load providers if interface supports that method
		if ($manifest instanceof Zend_Tool_Framework_Manifest_ProviderManifestable) {
			$providers = $manifest->getProviders();
			if (!is_array($providers)) {
				$providers = array($providers);
			}

			foreach ($providers as $provider) {
				if (!$provider instanceof Zend_Tool_Framework_Provider_Interface) {
					require_once 'Zend/Tool/Framework/Manifest/Exception.php';
					throw new Zend_Tool_Framework_Manifest_Exception(
                        'A provider provided by the ' . get_class($manifest)
					. ' does not implement Zend_Tool_Framework_Provider_Interface'
					);
				}
				if (!$providerRepository->hasProvider($provider, false)) {
					$providerRepository->addProvider($provider);
				}
			}

		}

		// load actions if interface supports that method
		if ($manifest instanceof Zend_Tool_Framework_Manifest_ActionManifestable) {
			$actions = $manifest->getActions();
			if (!is_array($actions)) {
				$actions = array($actions);
			}

			foreach ($actions as $action) {
				if (is_string($action)) {
					$action = new Zend_Tool_Framework_Action_Base($action);
				}
				$actionRepository->addAction($action);
			}
		}

		// should we detect collisions here? does it even matter?
		$this->_manifests[$index] = $manifest;
		ksort($this->_manifests);

		return $this;
	}

	/**
	 * getManifests()
	 *
	 * @return Zend_Tool_Framework_Manifest_Interface[]
	 */
	public function getManifests()
	{
		return $this->_manifests;
	}

	/**
	 * addMetadata() - add a metadata peice by peice
	 *
	 * @param Zend_Tool_Framework_Manifest_Metadata $metadata
	 * @return Zend_Tool_Framework_Manifest_Repository
	 */
	public function addMetadata(Zend_Tool_Framework_Metadata_Interface $metadata)
	{
		$this->_metadatas[] = $metadata;
		return $this;
	}

	/**
	 * process() - Process is expected to be called at the end of client construction time.
	 * By this time, the loader has run and loaded any found manifests into the repository
	 * for loading
	 *
	 * @return Zend_Tool_Framework_Manifest_Repository
	 */
	public function process()
	{

		foreach ($this->_manifests as $manifest) {
			if ($manifest instanceof Zend_Tool_Framework_Manifest_MetadataManifestable) {
				$metadatas = $manifest->getMetadata();
				if (!is_array($metadatas)) {
					$metadatas = array($metadatas);
				}

				foreach ($metadatas as $metadata) {
					if (!$metadata instanceof Zend_Tool_Framework_Metadata_Interface) {
						require_once 'Zend/Tool/Framework/Manifest/Exception.php';
						throw new Zend_Tool_Framework_Manifest_Exception(
                            'A Zend_Tool_Framework_Metadata_Interface object was not found in manifest ' . get_class($manifest)
						);
					}

					$this->addMetadata($metadata);
				}

			}
		}

		return $this;
	}

	/**
	 * getMetadatas() - This is the main search function for the repository.
	 *
	 * @example This will retrieve all metadata that matches the following criteria
	 *      $manifestRepo->getMetadatas(array(
	 *          'providerName' => 'Version',
	 *          'actionName' => 'show'
	 *          ));
	 *
	 * @param array $searchProperties
	 * @param bool $includeNonExistentProperties
	 * @return Zend_Tool_Framework_Manifest_Metadata[]
	 */
	public function getMetadatas(Array $searchProperties = array(), $includeNonExistentProperties = true)
	{

		$returnMetadatas = array();

		// loop through the metadatas so that we can search each individual one
		foreach ($this->_metadatas as $metadata) {

			// each value will be retrieved from the metadata, each metadata should
			// implement a getter method to retrieve the value
			foreach ($searchProperties as $searchPropertyName => $searchPropertyValue) {
				if (method_exists($metadata, 'get' . $searchPropertyName)) {
					if ($metadata->{'get' . $searchPropertyName}() != $searchPropertyValue) {
						// if the metadata supports a specific property but the value does not
						// match, move on
						continue 2;
					}
				} elseif (!$includeNonExistentProperties) {
					// if the option $includeNonExitentProperties is false, then move on as
					// we dont want to include this metadata if non existent
					// search properties are not inside the target (current) metadata
					continue 2;
				}
			}

			// all searching has been accounted for, if we reach this point, then the metadata
			// is good and we can return it
			$returnMetadatas[] = $metadata;

		}

		return $returnMetadatas;
	}

	/**
	 * getMetadata() - This will proxy to getMetadatas(), but will only return a single metadata.  This method
	 * should be used in situations where the search criteria is known to only find a single metadata object
	 *
	 * @param array $searchProperties
	 * @param bool $includeNonExistentProperties
	 * @return Zend_Tool_Framework_Manifest_Metadata
	 */
	public function getMetadata(Array $searchProperties = array(), $includeNonExistentProperties = true)
	{
		$metadatas = $this->getMetadatas($searchProperties, $includeNonExistentProperties);
		return array_shift($metadatas);
	}

	/**
	 * __toString() - cast to string
	 *
	 * @return string
	 */
	public function __toString()
	{
		$metadatasByType = array();

		foreach ($this->_metadatas as $metadata) {
			if (!array_key_exists($metadata->getType(), $metadatasByType)) {
				$metadatasByType[$metadata->getType()] = array();
			}
			$metadatasByType[$metadata->getType()][] = $metadata;
		}

		$string = '';
		foreach ($metadatasByType as $type => $metadatas) {
			$string .= $type . PHP_EOL;
			foreach ($metadatas as $metadata) {
				$metadataString = '    ' . $metadata->__toString() . PHP_EOL;
				//$metadataString = str_replace(PHP_EOL, PHP_EOL . '    ', $metadataString);
				$string .= $metadataString;
			}
		}

		return $string;
	}

	/**
	 * count() - required by the Countable Interface
	 *
	 * @return int
	 */
	public function count()
	{
		return count($this->_metadatas);
	}

	/**
	 * getIterator() - required by the IteratorAggregate interface
	 *
	 * @return ArrayIterator
	 */
	public function getIterator()
	{
		return new ArrayIterator($this->_metadatas);
	}

}
